//package kt.flows
//
//import kotlinx.coroutines.*
//import kotlinx.coroutines.channels.*
//
///**
// *
// *
// *
// * 1,简单的channel
// * channel.send             // 发送
// * channel.receive              // 接收
//
// * [simpleChannelDemo]
// *
// * 2，管道的关闭和迭代
// *  channel.close()
// *  for (y in channel) println(y)
// *
// * 3,创建管道
// * [createMyChannel]
// *
// *
// * 4，自己创建函数
// * [myCreateFun]
// *
// *
// * 扇出       多个协程也许会接收相同的管道，在它们之间进行分布式工作
// * [channelProcessOutinput]
// *
// * 扇入       多个协程可以发送到同一个通道
// * [channelProcessIninput]
// *
// *
// *
// * @see https://book.kotlincn.net/text/channels.html
// *
// *
// */
//
//fun main() {
////    channelsNumberSends()
////    channelProcessOutinput()
////    channelBufferDemo()
//    timeChannelDemo()
//}
//
//
//
//
//fun timeChannelDemo(){
//    runBlocking {
//
//        val tickerChannel = ticker(delayMillis = 100, initialDelayMillis = 0) //创建计时器通道
//
//        var nextElement = withTimeoutOrNull(1) {
//            tickerChannel.receive()
//        }
//
//        println("Initial element is available immediately: $nextElement") // no initial delay
//
//        nextElement = withTimeoutOrNull(50) {
//            tickerChannel.receive()
//        } // all subsequent elements have 100ms delay
//
//        println("Next element is not ready in 50 ms: $nextElement")
//
//        nextElement = withTimeoutOrNull(60) {
//            tickerChannel.receive()
//        }
//        println("Next element is ready in 100 ms: $nextElement")
//
//        // 模拟大量消费延迟
//        println("Consumer pauses for 150ms")
//        delay(150)
//
//        // 下一个元素立即可用
//        nextElement = withTimeoutOrNull(1) { tickerChannel.receive() }
//        println("Next element is available immediately after large consumer delay: $nextElement")
//
//        // 请注意，`receive` 调用之间的暂停被考虑在内，下一个元素的到达速度更快
//        nextElement = withTimeoutOrNull(60) { tickerChannel.receive() }
//        println("Next element is ready in 50ms after consumer pause in 150ms: $nextElement")
//
//        tickerChannel.cancel() // 表明不再需要更多的元素
//    }
//
//}
///*
// * Initial element is available immediately: kotlin.Unit
// * Next element is not ready in 50 ms: null
// * Next element is ready in 100 ms: kotlin.Unit
// * Consumer pauses for 150ms
// * Next element is available immediately after large consumer delay: kotlin.Unit
// * Next element is ready in 50ms after consumer pause in 150ms: kotlin.Unit
// */
//
//
//
//fun channelBufferDemo(){
//    runBlocking {
//        val channel = Channel<Int>(4) // 启动带缓冲的通道
//        val sender = launch { // 启动发送者协程
//            repeat(10) {
//                println("Sending $it") // 在每一个元素发送前打印它们
//                channel.send(it) // 将在缓冲区被占满时挂起
//            }
//        }
//        // 没有接收到东西……只是等待……
//        delay(1000)
//        sender.cancel() // 取消发送者协程
//    }
//}
//
//
//
//
//// 扇入
//fun channelProcessIninput() {
//
//    runBlocking {
//        val channel = Channel<String>()
//
//        launch { sendString(channel, "foo", 200L) }
//
//        launch { sendString(channel, "BAR!", 500L) }
//
//        repeat(6) { // 接收前六个
//            println(channel.receive())
//        }
//        coroutineContext.cancelChildren() // 取消所有子协程来让主协程结束
//    }
//
//}
//
//
//suspend fun sendString(channel: SendChannel<String>, s: String, time: Long) {
//    while (true) {
//        delay(time)
//        channel.send(s)
//    }
//}
//
//
//fun CoroutineScope.produceNumbers() = produce<Int> {
//    var x = 1 // start from 1
//    while (true) {
//        send(x++) // 产生下一个数字
//        delay(100) // 等待 0.1 秒
//    }
//}
//
//
//// 扇出
//fun channelProcessOutinput() {
//
//    runBlocking {
//        val producer = produceNumbers()
//
//        repeat(5) { value ->
//            launchProcessor(value, producer)
//        }
//
//        delay(950)
//        producer.cancel() // 取消协程生产者从而将它们全部杀死
//    }
//}
//
//
//fun CoroutineScope.launchProcessor(id: Int, channel: ReceiveChannel<Int>) = launch {
//    for (msg in channel) {
//        println("Processor #$id received $msg")
//    }
//}
//
//
//fun channelsNumberSends() {
//    runBlocking {
//        val numbers = produceNumbers() // 从 1 开始生成整数
//
////        val squares = square(numbers) // 整数求平方
//        val squares = myCreateFun(numbers) // 整数求平方
//
//        repeat(5) {
//            println(squares.receive()) // 输出前五个
//        }
//
//        println("Done!") // 至此已完成
//        coroutineContext.cancelChildren() // 取消子协程
//    }
//
//    /*
//                    1
//                    4
//                    9
//                    16
//                    25
//                    Done!
//     */
//}
//
////fun CoroutineScope.produceNumbers() = produce<Int> {
////    var x = 1
////    while (true) send(x++) // 从 1 开始的无限的整数流
////}
//
//fun CoroutineScope.square(numbers: ReceiveChannel<Int>): ReceiveChannel<Int> = produce {
//    for (x in numbers) send(x * x)
//}
//
///**
// * 这里是自己明明的函数
// */
//fun CoroutineScope.myCreateFun(numbers: ReceiveChannel<Int>): ReceiveChannel<Int> = produce {
//    for (x in numbers) send(x * x)
//}
//
//
//
//
//// 1
//fun simpleChannelDemo() {
//    runBlocking {
//        val channel = Channel<Int>()
//
//        launch {
//            // 这里可能是消耗大量 CPU 运算的异步逻辑，我们将仅仅做 5 次整数的平方并发送
//            for (x in 1..5)
//                channel.send(x * x)
//        }
//
//        // 这里我们打印了 5 次被接收的整数：
//        repeat(5) {
//            println(channel.receive())
//        }
//
//        println("Done!")
//    }
//
//}
//
//
//fun CoroutineScope.produceSquares(): ReceiveChannel<Int> = produce {
//    for (x in 1..5)
//        send(x * x)
//}
//
//
//fun createMyChannel() {
//    runBlocking {
//        val squares = produceSquares()
//        squares.consumeEach {
//            println(it)
//        }
//        println("Done!")
//    }
//}
//
//
